import {
	type SortDirection,
	type ColumnConfig,
	type HeaderCell,
	type SummaryType,
	type SummaryCell
} from '../context/table-context';

// 提取通用比较逻辑：提前传入排序方向和键类型，减少分支开销
export const createComparator = (
	sortDir: SortDirection,
	keyType: 'string' | 'number' | 'mixed'
) => {
	// 方向映射：ascend 返回 (a,b) => 比较结果，descend 返回 (a,b) => 反向比较结果
	const baseCompare = (a: any, b: any) => {
		// 提前处理 null/undefined（统一放到数组末尾）
		if (a == null && b == null) return 0;
		if (a == null) return 1;
		if (b == null) return -1;

		// 按预缓存的键类型比较，避免重复判断
		switch (keyType) {
			case 'number':
				return a - b;
			case 'string':
				// 优化：指定 sensitivity: 'base' 减少字符串比较开销，适配多语言
				return a.localeCompare(b);
			case 'mixed':
				// 混合类型：先转字符串再比较（保持原有逻辑但优化写法）
				const aStr = String(a);
				const bStr = String(b);
				return aStr.localeCompare(bStr);
		}
	};

	return sortDir === 'ascend' ? baseCompare : (a: any, b: any) => -baseCompare(a, b);
};

// 新增：辅助函数 - 深度比较两个值是否一致（支持基本类型+数组）
export const isValueEqual = (
	oldValue: string | number | (string | number)[] | null | undefined,
	newValue: string | number | (string | number)[] | null | undefined
): boolean => {
	// 1. 基本类型（null/undefined/string/number）直接全等比较
	if (oldValue === newValue) return true;

	// 2. 数组类型：判断长度+每一项是否一致
	if (Array.isArray(oldValue) && Array.isArray(newValue)) {
		if (oldValue.length !== newValue.length) return false;
		// 数组项排序后比较（避免因顺序不同导致判断失效，可根据需求决定是否排序）
		return oldValue.sort().join(',') === newValue.sort().join(',');
	}

	// 3. 类型不同（如旧值是数组，新值是字符串）直接返回不一致
	return false;
};

// 1. 获取所有叶子节点（用于 Grid 布局和表体渲染）
export const getLeafColumns = (cols: ColumnConfig[]): ColumnConfig[] => {
	let leaves: ColumnConfig[] = [];
	cols.forEach((col) => {
		// 🔥 如果显式设置为 false，则跳过
		if (col.visible === false) return;
		if (col.children && col.children.length > 0) {
			leaves = leaves.concat(getLeafColumns(col.children));
		} else {
			leaves.push(col);
		}
	});
	// console.log('getLeafColumns',leaves)
	return leaves;
};

// 2. 获取列及其所有后代叶子节点的 Key
export const getLeafKeys = (col: ColumnConfig): string[] => {
	if (!col.children || col.children.length === 0) return [col.key as string];
	return col.children.flatMap((child) => getLeafKeys(child));
};

// 3. 计算树的最大深度
const getDepth = (cols: ColumnConfig[]): number => {
	let max = 0;
	cols.forEach((col) => {
		if (col.visible === false) return; // 🔥
		let d = 1;
		if (col.children && col.children.length > 0) {
			d += getDepth(col.children);
		}
		if (d > max) max = d;
	});
	return max;
};

// 4. 构建表头行结构 (2D 数组)
// 返回结构： rows[level] = [ColumnConfig, ColumnConfig...]
export const getHeaderTree = (cols: ColumnConfig[]): { cols: HeaderCell[]; maxDepth: number } => {
	const visibleCols = cols.filter((c) => c.visible !== false);
	const maxDepth = getDepth(visibleCols);

	// 递归构建函数
	const traverse = (node: ColumnConfig, level: number): HeaderCell | null => {
		if (node.visible === false) return null; // 🔥
		const leaves = getLeafColumns([node]);
		// 如果非叶子节点且没有可见的子节点，则该组也不显示
		if (node.children && node.children.length > 0 && leaves.length === 0) {
			return null;
		}
		const leafCount = leaves.length;
		const isLeaf = !node.children || node.children.length === 0;

		// 计算 span
		// 如果是叶子，高度占满剩余层级；如果是组，只占 1 行高度
		const rowSpan = isLeaf ? maxDepth - level : 1;
		// colSpan 等于包含的叶子节点数
		const colSpan = leafCount;

		// 递归处理子节点，并过滤掉 null
		const childrenCells = node.children
			? node.children
					.map((child) => traverse(child, level + 1))
					.filter((c): c is HeaderCell => c !== null)
			: [];

		const cell: HeaderCell = {
			key: node.key as string,
			config: node,
			colSpan,
			rowSpan,
			level,
			isGroup: !isLeaf,
			// 🔥 递归构建子节点
			children: childrenCells
		};

		return cell;
	};

	// 对根列进行映射
	return {
		cols: visibleCols.map((col) => traverse(col, 0)).filter((c): c is HeaderCell => c !== null),
		maxDepth
	};
};

// 🔥 新增：聚合计算通用函数
export const calculateAggregate = (values: any[], type: SummaryType): number | null => {
	// 1. 提取有效数字
	const numbers = values
		.map((v) => Number(v))
		.filter((n) => !isNaN(n) && n !== null && n !== undefined);

	if (numbers.length === 0) return null;
	// console.log('calculateAggregate',values,type)

	switch (type) {
		case 'sum':
			// 简单的精度处理
			return Math.round(numbers.reduce((a, b) => a + b, 0) * 10000) / 10000;
		case 'avg':
			const sum = numbers.reduce((a, b) => a + b, 0);
			return Math.round((sum / numbers.length) * 10000) / 10000;
		case 'max':
			return Math.max(...numbers);
		case 'min':
			return Math.min(...numbers);
		case 'count':
			return numbers.length;
		default:
			return null;
	}
};

// 🔥 新增：生成合计行单元格（处理 ColSpan 和 Width 计算）
export const generateSummaryCells = (
	columns: ColumnConfig[],
	summaryData: Record<string, any>,
	columnWidths: Record<string, number>
): SummaryCell[] => {
	const cells: SummaryCell[] = [];
	let skipCount = 0; // 需要跳过的列数（用于被合并的列）

	for (let i = 0; i < columns.length; i++) {
		const col = columns[i];
		const key = col.key as string;

		// 如果当前列处于“被合并”状态，生成一个 skip 单元格并跳过
		if (skipCount > 0) {
			skipCount--;
			cells.push({
				key,
				value: '',
				colSpan: 0,
				width: 0,
				align: col.align,
				skip: true
			});
			continue;
		}

		// 获取当前列配置的 colSpan，默认为 1
		const colSpan = col.summaryColSpan && col.summaryColSpan > 1 ? col.summaryColSpan : 1;

		// 计算合并后的总宽度
		// 因为 Table 使用的是 flex/inline-block + pixel width，合并列不仅要占位，还要把后面几列的宽度加起来
		let totalWidth = columnWidths[key] || 0;

		// 如果 colSpan > 1，累加后续列的宽度
		if (colSpan > 1) {
			for (let j = 1; j < colSpan; j++) {
				// 边界检查：防止 colSpan 超出实际列数
				if (i + j < columns.length) {
					const nextKey = columns[i + j].key as string;
					const nextW = columnWidths[nextKey] || 0;
					totalWidth += nextW;
				}
			}
			// 设置后续需要跳过的列数
			skipCount = colSpan - 1;
		}

		cells.push({
			key,
			value: summaryData[key] ?? '',
			colSpan,
			width: totalWidth,
			align: col.align,
			skip: false
		});
	}

	return cells;
};
